home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gas_251.zip / bin_251 / binutils / syslex.c < prev    next >
C/C++ Source or Header  |  1994-10-13  |  35KB  |  1,400 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. #define FLEX_SCANNER
  4.  
  5. #include <stdio.h>
  6.  
  7.  
  8. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  9. #ifdef c_plusplus
  10. #ifndef __cplusplus
  11. #define __cplusplus
  12. #endif
  13. #endif
  14.  
  15.  
  16. #ifdef __cplusplus
  17.  
  18. #include <stdlib.h>
  19. #include <unistd.h>
  20.  
  21. /* Use prototypes in function declarations. */
  22. #define YY_USE_PROTOS
  23.  
  24. /* The "const" storage-class-modifier is valid. */
  25. #define YY_USE_CONST
  26.  
  27. #else    /* ! __cplusplus */
  28.  
  29. #ifdef __STDC__
  30.  
  31. #define YY_USE_PROTOS
  32. #define YY_USE_CONST
  33.  
  34. #endif    /* __STDC__ */
  35. #endif    /* ! __cplusplus */
  36.  
  37.  
  38. #ifdef __TURBOC__
  39. #define YY_USE_CONST
  40. #endif
  41.  
  42.  
  43. #ifndef YY_USE_CONST
  44. #ifndef const
  45. #define const
  46. #endif
  47. #endif
  48.  
  49.  
  50. #ifdef YY_USE_PROTOS
  51. #define YY_PROTO(proto) proto
  52. #else
  53. #define YY_PROTO(proto) ()
  54. #endif
  55.  
  56. /* Returned upon end-of-file. */
  57. #define YY_NULL 0
  58.  
  59. /* Promotes a possibly negative, possibly signed char to an unsigned
  60.  * integer for use as an array index.  If the signed char is negative,
  61.  * we want to instead treat it as an 8-bit unsigned char, hence the
  62.  * double cast.
  63.  */
  64. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  65.  
  66. /* Enter a start condition.  This macro really ought to take a parameter,
  67.  * but we do it the disgusting crufty way forced on us by the ()-less
  68.  * definition of BEGIN.
  69.  */
  70. #define BEGIN yy_start = 1 + 2 *
  71.  
  72. /* Translate the current start state into a value that can be later handed
  73.  * to BEGIN to return to the state.
  74.  */
  75. #define YY_START ((yy_start - 1) / 2)
  76.  
  77. /* Action number for EOF rule of a given start state. */
  78. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  79.  
  80. /* Special action meaning "start processing a new file".  Now included
  81.  * only for backward compatibility with previous versions of flex.
  82.  */
  83. #define YY_NEW_FILE yyrestart( yyin )
  84.  
  85. #define YY_END_OF_BUFFER_CHAR 0
  86.  
  87. /* Size of default input buffer. */
  88. #define YY_BUF_SIZE 16384
  89.  
  90. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  91.  
  92. extern int yyleng;
  93. extern FILE *yyin, *yyout;
  94.  
  95. #ifdef __cplusplus
  96. extern "C" {
  97. #endif
  98.     extern int yywrap YY_PROTO(( void ));
  99. #ifdef __cplusplus
  100.     }
  101. #endif
  102.  
  103. #define EOB_ACT_CONTINUE_SCAN 0
  104. #define EOB_ACT_END_OF_FILE 1
  105. #define EOB_ACT_LAST_MATCH 2
  106.  
  107. /* The funky do-while in the following #define is used to turn the definition
  108.  * int a single C statement (which needs a semi-colon terminator).  This
  109.  * avoids problems with code like:
  110.  *
  111.  *     if ( condition_holds )
  112.  *        yyless( 5 );
  113.  *    else
  114.  *        do_something_else();
  115.  *
  116.  * Prior to using the do-while the compiler would get upset at the
  117.  * "else" because it interpreted the "if" statement as being all
  118.  * done when it reached the ';' after the yyless() call.
  119.  */
  120.  
  121. /* Return all but the first 'n' matched characters back to the input stream. */
  122.  
  123. #define yyless(n) \
  124.     do \
  125.         { \
  126.         /* Undo effects of setting up yytext. */ \
  127.         *yy_cp = yy_hold_char; \
  128.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  129.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  130.         } \
  131.     while ( 0 )
  132.  
  133. #define unput(c) yyunput( c, yytext_ptr )
  134.  
  135.  
  136. struct yy_buffer_state
  137.     {
  138.     FILE *yy_input_file;
  139.  
  140.     char *yy_ch_buf;        /* input buffer */
  141.     char *yy_buf_pos;        /* current position in input buffer */
  142.  
  143.     /* Size of input buffer in bytes, not including room for EOB
  144.      * characters.
  145.      */
  146.     int yy_buf_size;
  147.  
  148.     /* Number of characters read into yy_ch_buf, not including EOB
  149.      * characters.
  150.      */
  151.     int yy_n_chars;
  152.  
  153.     /* Whether this is an "interactive" input source; if so, and
  154.      * if we're using stdio for input, then we want to use getc()
  155.      * instead of fread(), to make sure we stop fetching input after
  156.      * each newline.
  157.      */
  158.     int yy_is_interactive;
  159.  
  160.     /* Whether to try to fill the input buffer when we reach the
  161.      * end of it.
  162.      */
  163.     int yy_fill_buffer;
  164.  
  165.     /* Whether we've seen an EOF on this buffer. */
  166.     int yy_eof_status;
  167. #define EOF_NOT_SEEN 0
  168.     /* "Pending" happens when the EOF has been seen but there's still
  169.      * some text to process.  Note that when we actually see the EOF,
  170.      * we switch the status back to "not seen" (via yyrestart()), so
  171.      * that the user can continue scanning by just pointing yyin at
  172.      * a new input file.
  173.      */
  174. #define EOF_PENDING 1
  175.     };
  176.  
  177. static YY_BUFFER_STATE yy_current_buffer = 0;
  178.  
  179. /* We provide macros for accessing buffer states in case in the
  180.  * future we want to put the buffer states in a more general
  181.  * "scanner state".
  182.  */
  183. #define YY_CURRENT_BUFFER yy_current_buffer
  184.  
  185.  
  186. /* yy_hold_char holds the character lost when yytext is formed. */
  187. static char yy_hold_char;
  188.  
  189. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  190.  
  191.  
  192. int yyleng;
  193.  
  194. /* Points to current character in buffer. */
  195. static char *yy_c_buf_p = (char *) 0;
  196. static int yy_init = 1;        /* whether we need to initialize */
  197. static int yy_start = 0;    /* start state number */
  198.  
  199. /* Flag which is used to allow yywrap()'s to do buffer switches
  200.  * instead of setting up a fresh yyin.  A bit of a hack ...
  201.  */
  202. static int yy_did_buffer_switch_on_eof;
  203.  
  204. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  205. void yyrestart YY_PROTO(( FILE *input_file ));
  206. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  207. void yy_load_buffer_state YY_PROTO(( void ));
  208. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  209. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  210. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  211.  
  212. static int yy_start_stack_ptr = 0;
  213. static int yy_start_stack_depth = 0;
  214. static int *yy_start_stack = 0;
  215. static void yy_push_state YY_PROTO(( int new_state ));
  216. static void yy_pop_state YY_PROTO(( void ));
  217. static int yy_top_state YY_PROTO(( void ));
  218.  
  219. #ifndef yytext_ptr
  220. static void yy_flex_strcpy YY_PROTO(( char *, const char * ));
  221. #endif
  222.  
  223. static void *yy_flex_alloc YY_PROTO(( unsigned int ));
  224. static void *yy_flex_realloc YY_PROTO(( void *ptr, unsigned int ));
  225. static void yy_flex_free YY_PROTO(( void * ));
  226.  
  227. #define yy_new_buffer yy_create_buffer
  228.  
  229. #define INITIAL 0
  230. typedef unsigned char YY_CHAR;
  231. typedef int yy_state_type;
  232. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  233. extern char *yytext;
  234. #define yytext_ptr yytext
  235.  
  236. #ifdef __cplusplus
  237. static int yyinput YY_PROTO(( void ));
  238. #else
  239. static int input YY_PROTO(( void ));
  240. #endif
  241.  
  242. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  243. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  244. static int yy_get_next_buffer YY_PROTO(( void ));
  245. static void yy_fatal_error YY_PROTO(( const char msg[] ));
  246.  
  247. /* Done after the current pattern has been matched and before the
  248.  * corresponding action - sets up yytext.
  249.  */
  250. #define YY_DO_BEFORE_ACTION \
  251.     yytext_ptr = yy_bp; \
  252.     yyleng = yy_cp - yy_bp; \
  253.     yy_hold_char = *yy_cp; \
  254.     *yy_cp = '\0'; \
  255.     yy_c_buf_p = yy_cp;
  256.  
  257. #define YY_END_OF_BUFFER 26
  258. static const short int yy_accept[81] =
  259.     {   0,
  260.         0,    0,   26,   25,    7,    8,    5,   25,    1,    2,
  261.        11,   11,    6,    3,    4,   25,   25,   25,   25,   25,
  262.        25,   25,    0,    9,   11,    0,    6,    0,    0,    0,
  263.         0,    0,    0,    0,    0,    0,    0,   10,    0,    0,
  264.        13,    0,    0,    0,    0,   16,    0,    0,    0,    0,
  265.         0,   12,   15,    0,   23,    0,    0,    0,    0,    0,
  266.         0,   14,   18,    0,    0,    0,    0,    0,   17,    0,
  267.        24,    0,    0,    0,   20,   22,    0,   21,   19,    0
  268.     } ;
  269.  
  270. static const int yy_ec[256] =
  271.     {   0,
  272.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  273.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  274.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  275.         1,    4,    1,    5,    1,    1,    1,    1,    1,    6,
  276.         7,    1,    1,    1,    1,    1,    1,    8,    9,    9,
  277.         9,    9,    9,    9,    9,    9,    9,    1,   10,    1,
  278.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  279.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  280.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  281.        11,    1,   12,    1,    1,    1,   13,   14,   15,   16,
  282.  
  283.        17,   18,   19,   20,   21,    1,    1,   22,    1,   23,
  284.        24,   25,    1,   26,   27,   28,   29,   30,    1,   31,
  285.        32,   33,    1,    1,    1,    1,    1,    1,    1,    1,
  286.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  287.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  288.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  289.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  290.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  291.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  292.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  293.  
  294.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  295.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  296.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  297.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  298.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  299.         1,    1,    1,    1,    1
  300.     } ;
  301.  
  302. static const int yy_meta[34] =
  303.     {   0,
  304.         1,    1,    2,    1,    1,    1,    1,    3,    3,    1,
  305.         1,    1,    3,    3,    3,    3,    3,    3,    1,    1,
  306.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  307.         1,    1,    1
  308.     } ;
  309.  
  310. static const short int yy_base[84] =
  311.     {   0,
  312.         0,    0,  100,  101,  101,  101,  101,   94,  101,  101,
  313.        26,   28,    0,  101,  101,   82,   26,   18,   74,   79,
  314.        78,   81,   88,  101,   32,    0,    0,   76,   65,   62,
  315.        61,   75,   20,   59,   61,   66,   58,    0,   57,   56,
  316.        54,   63,   53,   62,   54,  101,   59,   48,   53,   46,
  317.        59,  101,   44,   43,  101,   41,   55,   46,   53,   44,
  318.        31,  101,  101,   39,   27,   21,   39,   19,  101,   35,
  319.       101,   33,   26,   29,  101,  101,   28,  101,  101,  101,
  320.        58,   61,   41
  321.     } ;
  322.  
  323. static const short int yy_def[84] =
  324.     {   0,
  325.        80,    1,   80,   80,   80,   80,   80,   81,   80,   80,
  326.        80,   80,   82,   80,   80,   80,   80,   80,   80,   80,
  327.        80,   80,   81,   80,   80,   83,   82,   80,   80,   80,
  328.        80,   80,   80,   80,   80,   80,   80,   83,   80,   80,
  329.        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  330.        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  331.        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  332.        80,   80,   80,   80,   80,   80,   80,   80,   80,    0,
  333.        80,   80,   80
  334.     } ;
  335.  
  336. static const short int yy_nxt[135] =
  337.     {   0,
  338.         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
  339.        14,   15,   16,   17,   18,    4,    4,    4,    4,    4,
  340.        19,    4,    4,    4,    4,   20,   21,    4,    4,   22,
  341.         4,    4,    4,   25,   25,   25,   25,   32,   29,   25,
  342.        25,   33,   44,   38,   79,   78,   30,   77,   45,   76,
  343.        75,   74,   73,   72,   71,   70,   26,   31,   23,   23,
  344.        23,   27,   69,   27,   68,   67,   66,   65,   64,   63,
  345.        62,   61,   60,   59,   58,   57,   56,   55,   54,   53,
  346.        52,   51,   50,   49,   48,   47,   46,   43,   42,   41,
  347.        40,   39,   24,   37,   36,   35,   34,   28,   24,   80,
  348.  
  349.         3,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  350.        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  351.        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  352.        80,   80,   80,   80
  353.     } ;
  354.  
  355. static const short int yy_chk[135] =
  356.     {   0,
  357.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  358.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  359.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  360.         1,    1,    1,   11,   11,   12,   12,   18,   17,   25,
  361.        25,   18,   33,   83,   77,   74,   17,   73,   33,   72,
  362.        70,   68,   67,   66,   65,   64,   11,   17,   81,   81,
  363.        81,   82,   61,   82,   60,   59,   58,   57,   56,   54,
  364.        53,   51,   50,   49,   48,   47,   45,   44,   43,   42,
  365.        41,   40,   39,   37,   36,   35,   34,   32,   31,   30,
  366.        29,   28,   23,   22,   21,   20,   19,   16,    8,    3,
  367.  
  368.        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  369.        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  370.        80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
  371.        80,   80,   80,   80
  372.     } ;
  373.  
  374. static yy_state_type yy_last_accepting_state;
  375. static char *yy_last_accepting_cpos;
  376.  
  377. /* The intent behind this definition is that it'll catch
  378.  * any uses of REJECT which flex missed.
  379.  */
  380. #define REJECT reject_used_but_not_detected
  381. #define yymore() yymore_used_but_not_detected
  382. #define YY_MORE_ADJ 0
  383. char *yytext;
  384. # line 1 "./syslex.l"
  385. # line 2 "./syslex.l"
  386. #include "sysinfo.h"
  387. char *word;
  388. int number;
  389. int unit;
  390.  
  391. #ifndef yywrap
  392. static int yywrap () { return 1; }
  393. #endif
  394.  
  395. /* Macros after this point can all be overridden by user definitions in
  396.  * section 1.
  397.  */
  398.  
  399. #ifdef YY_MALLOC_DECL
  400. YY_MALLOC_DECL
  401. #else
  402. #if __STDC__
  403. #ifndef __cplusplus
  404. #include <stdlib.h>
  405. #endif
  406. #else
  407. /* Just try to get by without declaring the routines.  This will fail
  408.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  409.  * or sizeof(void*) != sizeof(int).
  410.  */
  411. #endif
  412. #endif
  413.  
  414. /* Amount of stuff to slurp up with each read. */
  415. #ifndef YY_READ_BUF_SIZE
  416. #define YY_READ_BUF_SIZE 8192
  417. #endif
  418.  
  419. /* Copy whatever the last rule matched to the standard output. */
  420.  
  421. #ifndef ECHO
  422. /* This used to be an fputs(), but since the string might contain NUL's,
  423.  * we now use fwrite().
  424.  */
  425. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  426. #endif
  427.  
  428. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  429.  * is returned in "result".
  430.  */
  431. #ifndef YY_INPUT
  432. #define YY_INPUT(buf,result,max_size) \
  433.     if ( yy_current_buffer->yy_is_interactive ) \
  434.         { \
  435.         int c = getc( yyin ); \
  436.         result = c == EOF ? 0 : 1; \
  437.         buf[0] = (char) c; \
  438.         } \
  439.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  440.           && ferror( yyin ) ) \
  441.         YY_FATAL_ERROR( "input in flex scanner failed" );
  442. #endif
  443.  
  444. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  445.  * we don't want an extra ';' after the "return" because that will cause
  446.  * some compilers to complain about unreachable statements.
  447.  */
  448. #ifndef yyterminate
  449. #define yyterminate() return YY_NULL
  450. #endif
  451.  
  452. /* Number of entries by which start-condition stack grows. */
  453. #ifndef YY_START_STACK_INCR
  454. #define YY_START_STACK_INCR 25
  455. #endif
  456.  
  457. /* Report a fatal error. */
  458. #ifndef YY_FATAL_ERROR
  459. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  460. #endif
  461.  
  462. /* Default declaration of generated scanner - a define so the user can
  463.  * easily add parameters.
  464.  */
  465. #ifndef YY_DECL
  466. #define YY_DECL int yylex YY_PROTO(( void ))
  467. #endif
  468.  
  469. /* Code executed at the beginning of each rule, after yytext and yyleng
  470.  * have been set up.
  471.  */
  472. #ifndef YY_USER_ACTION
  473. #define YY_USER_ACTION
  474. #endif
  475.  
  476. /* Code executed at the end of each rule. */
  477. #ifndef YY_BREAK
  478. #define YY_BREAK break;
  479. #endif
  480.  
  481. YY_DECL
  482.     {
  483.     register yy_state_type yy_current_state;
  484.     register char *yy_cp, *yy_bp;
  485.     register int yy_act;
  486.  
  487. # line 11 "./syslex.l"
  488.  
  489.  
  490.     if ( yy_init )
  491.         {
  492. #ifdef YY_USER_INIT
  493.         YY_USER_INIT;
  494. #endif
  495.  
  496.         if ( ! yy_start )
  497.             yy_start = 1;    /* first start state */
  498.  
  499.         if ( ! yyin )
  500.             yyin = stdin;
  501.  
  502.         if ( ! yyout )
  503.             yyout = stdout;
  504.  
  505.         if ( yy_current_buffer )
  506.             yy_init_buffer( yy_current_buffer, yyin );
  507.         else
  508.             yy_current_buffer =
  509.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  510.  
  511.         yy_load_buffer_state();
  512.  
  513.         yy_init = 0;
  514.         }
  515.  
  516.     while ( 1 )        /* loops until end-of-file is reached */
  517.         {
  518.         yy_cp = yy_c_buf_p;
  519.  
  520.         /* Support of yytext. */
  521.         *yy_cp = yy_hold_char;
  522.  
  523.         /* yy_bp points to the position in yy_ch_buf of the start of
  524.          * the current run.
  525.          */
  526.         yy_bp = yy_cp;
  527.  
  528.         yy_current_state = yy_start;
  529. yy_match:
  530.         do
  531.             {
  532.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  533.             if ( yy_accept[yy_current_state] )
  534.                 {
  535.                 yy_last_accepting_state = yy_current_state;
  536.                 yy_last_accepting_cpos = yy_cp;
  537.                 }
  538.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  539.                 {
  540.                 yy_current_state = (int) yy_def[yy_current_state];
  541.                 if ( yy_current_state >= 81 )
  542.                     yy_c = yy_meta[(unsigned int) yy_c];
  543.                 }
  544.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  545.             ++yy_cp;
  546.             }
  547.         while ( yy_base[yy_current_state] != 101 );
  548.  
  549. yy_find_action:
  550.         yy_act = yy_accept[yy_current_state];
  551.  
  552.         YY_DO_BEFORE_ACTION;
  553.  
  554.  
  555. do_action:    /* This label is used only to access EOF actions. */
  556.  
  557.  
  558.         switch ( yy_act )
  559.     { /* beginning of action switch */
  560.             case 0: /* must back up */
  561.             /* undo the effects of YY_DO_BEFORE_ACTION */
  562.             *yy_cp = yy_hold_char;
  563.             yy_cp = yy_last_accepting_cpos;
  564.             yy_current_state = yy_last_accepting_state;
  565.             goto yy_find_action;
  566.  
  567. case 1:
  568. YY_USER_ACTION
  569. # line 12 "./syslex.l"
  570. { return '(';}
  571.     YY_BREAK
  572. case 2:
  573. YY_USER_ACTION
  574. # line 13 "./syslex.l"
  575. { return ')';}
  576.     YY_BREAK
  577. case 3:
  578. YY_USER_ACTION
  579. # line 14 "./syslex.l"
  580. { return '[';}
  581.     YY_BREAK
  582. case 4:
  583. YY_USER_ACTION
  584. # line 15 "./syslex.l"
  585. { return ']';}
  586.     YY_BREAK
  587. case 5:
  588. YY_USER_ACTION
  589. # line 16 "./syslex.l"
  590. { ; }
  591.     YY_BREAK
  592. case 6:
  593. YY_USER_ACTION
  594. # line 17 "./syslex.l"
  595. { ; } 
  596.     YY_BREAK
  597. case 7:
  598. YY_USER_ACTION
  599. # line 18 "./syslex.l"
  600. { ; }
  601.     YY_BREAK
  602. case 8:
  603. YY_USER_ACTION
  604. # line 19 "./syslex.l"
  605. { ; }
  606.     YY_BREAK
  607. case 9:
  608. YY_USER_ACTION
  609. # line 20 "./syslex.l"
  610. {
  611. yylval.s = malloc(strlen (yytext));
  612. strcpy(yylval.s, yytext+1);
  613. yylval.s[strlen(yylval.s)-1] = 0;
  614.         return NAME;
  615.     }
  616.     YY_BREAK
  617. case 10:
  618. YY_USER_ACTION
  619. # line 27 "./syslex.l"
  620. {
  621.         yylval.i = strtol(yytext,0,16);
  622.     return  NUMBER;
  623.     }
  624.     YY_BREAK
  625. case 11:
  626. YY_USER_ACTION
  627. # line 32 "./syslex.l"
  628. {
  629.         yylval.i = atoi(yytext);
  630.     return  NUMBER;
  631.     }
  632.     YY_BREAK
  633. case 12:
  634. YY_USER_ACTION
  635. # line 38 "./syslex.l"
  636. { yylval.i =1 ;return UNIT;}
  637.     YY_BREAK
  638. case 13:
  639. YY_USER_ACTION
  640. # line 39 "./syslex.l"
  641. { yylval.i = 1; return UNIT;}
  642.     YY_BREAK
  643. case 14:
  644. YY_USER_ACTION
  645. # line 40 "./syslex.l"
  646. { yylval.i= 8; return UNIT;}
  647.     YY_BREAK
  648. case 15:
  649. YY_USER_ACTION
  650. # line 41 "./syslex.l"
  651. { yylval.i = 8; return UNIT;}
  652.     YY_BREAK
  653. case 16:
  654. YY_USER_ACTION
  655. # line 43 "./syslex.l"
  656. { yylval.s = "INT"; return TYPE;}
  657.     YY_BREAK
  658. case 17:
  659. YY_USER_ACTION
  660. # line 44 "./syslex.l"
  661. { yylval.s = "BARRAY"; return TYPE;}
  662.     YY_BREAK
  663. case 18:
  664. YY_USER_ACTION
  665. # line 45 "./syslex.l"
  666. { yylval.s = "CHARS"; return TYPE;}
  667.     YY_BREAK
  668. case 19:
  669. YY_USER_ACTION
  670. # line 46 "./syslex.l"
  671. { yylval.i = 0; return NUMBER;}
  672.     YY_BREAK
  673. case 20:
  674. YY_USER_ACTION
  675. # line 47 "./syslex.l"
  676. { yylval.i = -4; return NUMBER;}
  677.     YY_BREAK
  678. case 21:
  679. YY_USER_ACTION
  680. # line 48 "./syslex.l"
  681. { yylval.i = -2; return NUMBER; }
  682.     YY_BREAK
  683. case 22:
  684. YY_USER_ACTION
  685. # line 49 "./syslex.l"
  686. { yylval.i = -1; return NUMBER; }
  687.     YY_BREAK
  688. case 23:
  689. YY_USER_ACTION
  690. # line 50 "./syslex.l"
  691. { return COND;}
  692.     YY_BREAK
  693. case 24:
  694. YY_USER_ACTION
  695. # line 51 "./syslex.l"
  696. { return REPEAT;}
  697.     YY_BREAK
  698. case 25:
  699. YY_USER_ACTION
  700. # line 52 "./syslex.l"
  701. ECHO;
  702.     YY_BREAK
  703. case YY_STATE_EOF(INITIAL):
  704.     yyterminate();
  705.  
  706.     case YY_END_OF_BUFFER:
  707.         {
  708.         /* Amount of text matched not including the EOB char. */
  709.         int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
  710.  
  711.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  712.         *yy_cp = yy_hold_char;
  713.  
  714.         if ( yy_current_buffer->yy_input_file != yyin )
  715.             {
  716.             /* This can happen if we scan a file, yywrap() returns
  717.              * 1, and then later the user points yyin at a new
  718.              * file to resume scanning.  We have to assure
  719.              * consistency between yy_current_buffer and our
  720.              * globals.  Here is the right place to do so, because
  721.              * this is the first action (other than possibly a
  722.              * back-up) that will match for the new input file.
  723.              */
  724.             yy_current_buffer->yy_input_file = yyin;
  725.             yy_n_chars = yy_current_buffer->yy_n_chars;
  726.             }
  727.  
  728.         /* Note that here we test for yy_c_buf_p "<=" to the position
  729.          * of the first EOB in the buffer, since yy_c_buf_p will
  730.          * already have been incremented past the NUL character
  731.          * (since all states make transitions on EOB to the
  732.          * end-of-buffer state).  Contrast this with the test
  733.          * in input().
  734.          */
  735.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  736.             { /* This was really a NUL. */
  737.             yy_state_type yy_next_state;
  738.  
  739.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  740.  
  741.             yy_current_state = yy_get_previous_state();
  742.  
  743.             /* Okay, we're now positioned to make the NUL
  744.              * transition.  We couldn't have
  745.              * yy_get_previous_state() go ahead and do it
  746.              * for us because it doesn't know how to deal
  747.              * with the possibility of jamming (and we don't
  748.              * want to build jamming into it because then it
  749.              * will run more slowly).
  750.              */
  751.  
  752.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  753.  
  754.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  755.  
  756.             if ( yy_next_state )
  757.                 {
  758.                 /* Consume the NUL. */
  759.                 yy_cp = ++yy_c_buf_p;
  760.                 yy_current_state = yy_next_state;
  761.                 goto yy_match;
  762.                 }
  763.  
  764.             else
  765.                 {
  766.                 goto yy_find_action;
  767.                 }
  768.             }
  769.  
  770.         else switch ( yy_get_next_buffer() )
  771.             {
  772.             case EOB_ACT_END_OF_FILE:
  773.                 {
  774.                 yy_did_buffer_switch_on_eof = 0;
  775.  
  776.                 if ( yywrap() )
  777.                     {
  778.                     /* Note: because we've taken care in
  779.                      * yy_get_next_buffer() to have set up
  780.                      * yytext, we can now set up
  781.                      * yy_c_buf_p so that if some total
  782.                      * hoser (like flex itself) wants to
  783.                      * call the scanner after we return the
  784.                      * YY_NULL, it'll still work - another
  785.                      * YY_NULL will get returned.
  786.                      */
  787.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  788.  
  789.                     yy_act = YY_STATE_EOF(YY_START);
  790.                     goto do_action;
  791.                     }
  792.  
  793.                 else
  794.                     {
  795.                     if ( ! yy_did_buffer_switch_on_eof )
  796.                         YY_NEW_FILE;
  797.                     }
  798.                 break;
  799.                 }
  800.  
  801.             case EOB_ACT_CONTINUE_SCAN:
  802.                 yy_c_buf_p =
  803.                     yytext_ptr + yy_amount_of_matched_text;
  804.  
  805.                 yy_current_state = yy_get_previous_state();
  806.  
  807.                 yy_cp = yy_c_buf_p;
  808.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  809.                 goto yy_match;
  810.  
  811.             case EOB_ACT_LAST_MATCH:
  812.                 yy_c_buf_p =
  813.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  814.  
  815.                 yy_current_state = yy_get_previous_state();
  816.  
  817.                 yy_cp = yy_c_buf_p;
  818.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  819.                 goto yy_find_action;
  820.             }
  821.         break;
  822.         }
  823.  
  824.     default:
  825.         YY_FATAL_ERROR(
  826.             "fatal flex scanner internal error--no action found" );
  827.     } /* end of action switch */
  828.         } /* end of scanning one token */
  829.     } /* end of yylex */
  830.  
  831.  
  832. /* yy_get_next_buffer - try to read in a new buffer
  833.  *
  834.  * Returns a code representing an action:
  835.  *    EOB_ACT_LAST_MATCH -
  836.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  837.  *    EOB_ACT_END_OF_FILE - end of file
  838.  */
  839.  
  840. static int yy_get_next_buffer()
  841.     {
  842.     register char *dest = yy_current_buffer->yy_ch_buf;
  843.     register char *source = yytext_ptr - 1; /* copy prev. char, too */
  844.     register int number_to_move, i;
  845.     int ret_val;
  846.  
  847.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  848.         YY_FATAL_ERROR(
  849.         "fatal flex scanner internal error--end of buffer missed" );
  850.  
  851.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  852.         { /* Don't try to fill the buffer, so this is an EOF. */
  853.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  854.             {
  855.             /* We matched a singled characater, the EOB, so
  856.              * treat this as a final EOF.
  857.              */
  858.             return EOB_ACT_END_OF_FILE;
  859.             }
  860.  
  861.         else
  862.             {
  863.             /* We matched some text prior to the EOB, first
  864.              * process it.
  865.              */
  866.             return EOB_ACT_LAST_MATCH;
  867.             }
  868.         }
  869.  
  870.     /* Try to read more data. */
  871.  
  872.     /* First move last chars to start of buffer. */
  873.     number_to_move = yy_c_buf_p - yytext_ptr;
  874.  
  875.     for ( i = 0; i < number_to_move; ++i )
  876.         *(dest++) = *(source++);
  877.  
  878.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  879.         /* don't do the read, it's not guaranteed to return an EOF,
  880.          * just force an EOF
  881.          */
  882.         yy_n_chars = 0;
  883.  
  884.     else
  885.         {
  886.         int num_to_read =
  887.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  888.  
  889.         while ( num_to_read <= 0 )
  890.             { /* Not enough room in the buffer - grow it. */
  891. #ifdef YY_USES_REJECT
  892.             YY_FATAL_ERROR(
  893. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  894. #else
  895.  
  896.             /* just a shorter name for the current buffer */
  897.             YY_BUFFER_STATE b = yy_current_buffer;
  898.  
  899.             int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
  900.  
  901.             b->yy_buf_size *= 2;
  902.             b->yy_ch_buf = (char *)
  903.                 yy_flex_realloc( (void *) b->yy_ch_buf,
  904.                          b->yy_buf_size );
  905.  
  906.             if ( ! b->yy_ch_buf )
  907.                 YY_FATAL_ERROR(
  908.                 "fatal error - scanner input buffer overflow" );
  909.  
  910.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  911.  
  912.             num_to_read = yy_current_buffer->yy_buf_size -
  913.                         number_to_move - 1;
  914. #endif
  915.             }
  916.  
  917.         if ( num_to_read > YY_READ_BUF_SIZE )
  918.             num_to_read = YY_READ_BUF_SIZE;
  919.  
  920.         /* Read in more data. */
  921.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  922.             yy_n_chars, num_to_read );
  923.         }
  924.  
  925.     if ( yy_n_chars == 0 )
  926.         {
  927.         if ( number_to_move - YY_MORE_ADJ == 1 )
  928.             {
  929.             ret_val = EOB_ACT_END_OF_FILE;
  930.             yyrestart( yyin );
  931.             }
  932.  
  933.         else
  934.             {
  935.             ret_val = EOB_ACT_LAST_MATCH;
  936.             yy_current_buffer->yy_eof_status = EOF_PENDING;
  937.             }
  938.         }
  939.  
  940.     else
  941.         ret_val = EOB_ACT_CONTINUE_SCAN;
  942.  
  943.     yy_n_chars += number_to_move;
  944.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  945.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  946.  
  947.     /* yytext begins at the second character in yy_ch_buf; the first
  948.      * character is the one which preceded it before reading in the latest
  949.      * buffer; it needs to be kept around in case it's a newline, so
  950.      * yy_get_previous_state() will have with '^' rules active.
  951.      */
  952.  
  953.     yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
  954.  
  955.     return ret_val;
  956.     }
  957.  
  958.  
  959. /* yy_get_previous_state - get the state just before the EOB char was reached */
  960.  
  961. static yy_state_type yy_get_previous_state()
  962.     {
  963.     register yy_state_type yy_current_state;
  964.     register char *yy_cp;
  965.  
  966.     yy_current_state = yy_start;
  967.  
  968.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  969.         {
  970.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  971.         if ( yy_accept[yy_current_state] )
  972.             {
  973.             yy_last_accepting_state = yy_current_state;
  974.             yy_last_accepting_cpos = yy_cp;
  975.             }
  976.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  977.             {
  978.             yy_current_state = (int) yy_def[yy_current_state];
  979.             if ( yy_current_state >= 81 )
  980.                 yy_c = yy_meta[(unsigned int) yy_c];
  981.             }
  982.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  983.         }
  984.  
  985.     return yy_current_state;
  986.     }
  987.  
  988.  
  989. /* yy_try_NUL_trans - try to make a transition on the NUL character
  990.  *
  991.  * synopsis
  992.  *    next_state = yy_try_NUL_trans( current_state );
  993.  */
  994.  
  995. #ifdef YY_USE_PROTOS
  996. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  997. #else
  998. static yy_state_type yy_try_NUL_trans( yy_current_state )
  999. yy_state_type yy_current_state;
  1000. #endif
  1001.     {
  1002.     register int yy_is_jam;
  1003.     register char *yy_cp = yy_c_buf_p;
  1004.  
  1005.     register YY_CHAR yy_c = 1;
  1006.     if ( yy_accept[yy_current_state] )
  1007.         {
  1008.         yy_last_accepting_state = yy_current_state;
  1009.         yy_last_accepting_cpos = yy_cp;
  1010.         }
  1011.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1012.         {
  1013.         yy_current_state = (int) yy_def[yy_current_state];
  1014.         if ( yy_current_state >= 81 )
  1015.             yy_c = yy_meta[(unsigned int) yy_c];
  1016.         }
  1017.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1018.     yy_is_jam = (yy_current_state == 80);
  1019.  
  1020.     return yy_is_jam ? 0 : yy_current_state;
  1021.     }
  1022.  
  1023.  
  1024. #ifdef YY_USE_PROTOS
  1025. static void yyunput( int c, register char *yy_bp )
  1026. #else
  1027. static void yyunput( c, yy_bp )
  1028. int c;
  1029. register char *yy_bp;
  1030. #endif
  1031.     {
  1032.     register char *yy_cp = yy_c_buf_p;
  1033.  
  1034.     /* undo effects of setting up yytext */
  1035.     *yy_cp = yy_hold_char;
  1036.  
  1037.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1038.         { /* need to shift things up to make room */
  1039.         /* +2 for EOB chars. */
  1040.         register int number_to_move = yy_n_chars + 2;
  1041.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1042.                     yy_current_buffer->yy_buf_size + 2];
  1043.         register char *source =
  1044.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1045.  
  1046.         while ( source > yy_current_buffer->yy_ch_buf )
  1047.             *--dest = *--source;
  1048.  
  1049.         yy_cp += dest - source;
  1050.         yy_bp += dest - source;
  1051.         yy_n_chars = yy_current_buffer->yy_buf_size;
  1052.  
  1053.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1054.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1055.         }
  1056.  
  1057.     if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
  1058.         yy_cp[-2] = '\n';
  1059.  
  1060.     *--yy_cp = (char) c;
  1061.  
  1062.  
  1063.     /* Note: the formal parameter *must* be called "yy_bp" for this
  1064.      * macro to now work correctly.
  1065.      */
  1066.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1067.     }
  1068.  
  1069.  
  1070. #ifdef __cplusplus
  1071. static int yyinput()
  1072. #else
  1073. static int input()
  1074. #endif
  1075.     {
  1076.     int c;
  1077.  
  1078.     *yy_c_buf_p = yy_hold_char;
  1079.  
  1080.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1081.         {
  1082.         /* yy_c_buf_p now points to the character we want to return.
  1083.          * If this occurs *before* the EOB characters, then it's a
  1084.          * valid NUL; if not, then we've hit the end of the buffer.
  1085.          */
  1086.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1087.             /* This was really a NUL. */
  1088.             *yy_c_buf_p = '\0';
  1089.  
  1090.         else
  1091.             { /* need more input */
  1092.             yytext_ptr = yy_c_buf_p;
  1093.             ++yy_c_buf_p;
  1094.  
  1095.             switch ( yy_get_next_buffer() )
  1096.                 {
  1097.                 case EOB_ACT_END_OF_FILE:
  1098.                     {
  1099.                     if ( yywrap() )
  1100.                         {
  1101.                         yy_c_buf_p =
  1102.                         yytext_ptr + YY_MORE_ADJ;
  1103.                         return EOF;
  1104.                         }
  1105.  
  1106.                     YY_NEW_FILE;
  1107. #ifdef __cplusplus
  1108.                     return yyinput();
  1109. #else
  1110.                     return input();
  1111. #endif
  1112.                     }
  1113.  
  1114.                 case EOB_ACT_CONTINUE_SCAN:
  1115.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1116.                     break;
  1117.  
  1118.                 case EOB_ACT_LAST_MATCH:
  1119. #ifdef __cplusplus
  1120.                     YY_FATAL_ERROR(
  1121.                     "unexpected last match in yyinput()" );
  1122. #else
  1123.                     YY_FATAL_ERROR(
  1124.                     "unexpected last match in input()" );
  1125. #endif
  1126.                 }
  1127.             }
  1128.         }
  1129.  
  1130.     c = *yy_c_buf_p;
  1131.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1132.     yy_hold_char = *++yy_c_buf_p;
  1133.  
  1134.     return c;
  1135.     }
  1136.  
  1137.  
  1138. #ifdef YY_USE_PROTOS
  1139. void yyrestart( FILE *input_file )
  1140. #else
  1141. void yyrestart( input_file )
  1142. FILE *input_file;
  1143. #endif
  1144.     {
  1145.     if ( ! yy_current_buffer )
  1146.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1147.  
  1148.     yy_init_buffer( yy_current_buffer, input_file );
  1149.     yy_load_buffer_state();
  1150.     }
  1151.  
  1152.  
  1153. #ifdef YY_USE_PROTOS
  1154. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1155. #else
  1156. void yy_switch_to_buffer( new_buffer )
  1157. YY_BUFFER_STATE new_buffer;
  1158. #endif
  1159.     {
  1160.     if ( yy_current_buffer == new_buffer )
  1161.         return;
  1162.  
  1163.     if ( yy_current_buffer )
  1164.         {
  1165.         /* Flush out information for old buffer. */
  1166.         *yy_c_buf_p = yy_hold_char;
  1167.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1168.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1169.         }
  1170.  
  1171.     yy_current_buffer = new_buffer;
  1172.     yy_load_buffer_state();
  1173.  
  1174.     /* We don't actually know whether we did this switch during
  1175.      * EOF (yywrap()) processing, but the only time this flag
  1176.      * is looked at is after yywrap() is called, so it's safe
  1177.      * to go ahead and always set it.
  1178.      */
  1179.     yy_did_buffer_switch_on_eof = 1;
  1180.     }
  1181.  
  1182.  
  1183. #ifdef YY_USE_PROTOS
  1184. void yy_load_buffer_state( void )
  1185. #else
  1186. void yy_load_buffer_state()
  1187. #endif
  1188.     {
  1189.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1190.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1191.     yyin = yy_current_buffer->yy_input_file;
  1192.     yy_hold_char = *yy_c_buf_p;
  1193.     }
  1194.  
  1195.  
  1196. #ifdef YY_USE_PROTOS
  1197. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1198. #else
  1199. YY_BUFFER_STATE yy_create_buffer( file, size )
  1200. FILE *file;
  1201. int size;
  1202. #endif
  1203.     {
  1204.     YY_BUFFER_STATE b;
  1205.  
  1206.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1207.  
  1208.     if ( ! b )
  1209.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1210.  
  1211.     b->yy_buf_size = size;
  1212.  
  1213.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1214.      * we need to put in 2 end-of-buffer characters.
  1215.      */
  1216.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1217.  
  1218.     if ( ! b->yy_ch_buf )
  1219.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1220.  
  1221.     yy_init_buffer( b, file );
  1222.  
  1223.     return b;
  1224.     }
  1225.  
  1226.  
  1227. #ifdef YY_USE_PROTOS
  1228. void yy_delete_buffer( YY_BUFFER_STATE b )
  1229. #else
  1230. void yy_delete_buffer( b )
  1231. YY_BUFFER_STATE b;
  1232. #endif
  1233.     {
  1234.     if ( b == yy_current_buffer )
  1235.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1236.  
  1237.     yy_flex_free( (void *) b->yy_ch_buf );
  1238.     yy_flex_free( (void *) b );
  1239.     }
  1240.  
  1241.  
  1242. #ifdef YY_USE_PROTOS
  1243. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1244. #else
  1245. void yy_init_buffer( b, file )
  1246. YY_BUFFER_STATE b;
  1247. FILE *file;
  1248. #endif
  1249.     {
  1250.     b->yy_input_file = file;
  1251.  
  1252.     /* We put in the '\n' and start reading from [1] so that an
  1253.      * initial match-at-newline will be true.
  1254.      */
  1255.  
  1256.     b->yy_ch_buf[0] = '\n';
  1257.     b->yy_n_chars = 1;
  1258.  
  1259.     /* We always need two end-of-buffer characters.  The first causes
  1260.      * a transition to the end-of-buffer state.  The second causes
  1261.      * a jam in that state.
  1262.      */
  1263.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1264.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1265.  
  1266.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1267.  
  1268.     b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
  1269.  
  1270.     b->yy_fill_buffer = 1;
  1271.  
  1272.     b->yy_eof_status = EOF_NOT_SEEN;
  1273.     }
  1274.  
  1275.  
  1276. #ifdef YY_USE_PROTOS
  1277. static void yy_push_state( int new_state )
  1278. #else
  1279. static void yy_push_state( new_state )
  1280. int new_state;
  1281. #endif
  1282.     {
  1283.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1284.         {
  1285.         int new_size;
  1286.  
  1287.         yy_start_stack_depth += YY_START_STACK_INCR;
  1288.         new_size = yy_start_stack_depth * sizeof( int );
  1289.  
  1290.         if ( ! yy_start_stack )
  1291.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1292.  
  1293.         else
  1294.             yy_start_stack = (int *) yy_flex_realloc(
  1295.                     (void *) yy_start_stack, new_size );
  1296.  
  1297.         if ( ! yy_start_stack )
  1298.             YY_FATAL_ERROR(
  1299.             "out of memory expanding start-condition stack" );
  1300.         }
  1301.  
  1302.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1303.  
  1304.     BEGIN(new_state);
  1305.     }
  1306.  
  1307.  
  1308. static void yy_pop_state()
  1309.     {
  1310.     if ( --yy_start_stack_ptr < 0 )
  1311.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1312.  
  1313.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1314.     }
  1315.  
  1316.  
  1317. static int yy_top_state()
  1318.     {
  1319.     return yy_start_stack[yy_start_stack_ptr - 1];
  1320.     }
  1321.  
  1322.  
  1323. #ifdef YY_USE_PROTOS
  1324. static void yy_fatal_error( const char msg[] )
  1325. #else
  1326. static void yy_fatal_error( msg )
  1327. char msg[];
  1328. #endif
  1329.     {
  1330.     (void) fprintf( stderr, "%s\n", msg );
  1331.     exit( 1 );
  1332.     }
  1333.  
  1334.  
  1335.  
  1336. /* Redefine yyless() so it works in section 3 code. */
  1337.  
  1338. #undef yyless
  1339. #define yyless(n) \
  1340.     do \
  1341.         { \
  1342.         /* Undo effects of setting up yytext. */ \
  1343.         yytext[yyleng] = yy_hold_char; \
  1344.         yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
  1345.         yy_hold_char = *yy_c_buf_p; \
  1346.         *yy_c_buf_p = '\0'; \
  1347.         yyleng = n; \
  1348.         } \
  1349.     while ( 0 )
  1350.  
  1351.  
  1352. /* Internal utility routines. */
  1353.  
  1354. #ifndef yytext_ptr
  1355. #ifdef YY_USE_PROTOS
  1356. static void yy_flex_strcpy( char *s1, const char *s2 )
  1357. #else
  1358. static void yy_flex_strcpy( s1, s2 )
  1359. char *s1;
  1360. const char *s2;
  1361. #endif
  1362.     {
  1363.     while ( (*(s1++) = *(s2++)) )
  1364.         ;
  1365.     }
  1366. #endif
  1367.  
  1368.  
  1369. #ifdef YY_USE_PROTOS
  1370. static void *yy_flex_alloc( unsigned int size )
  1371. #else
  1372. static void *yy_flex_alloc( size )
  1373. unsigned int size;
  1374. #endif
  1375.     {
  1376.     return (void *) malloc( size );
  1377.     }
  1378.  
  1379. #ifdef YY_USE_PROTOS
  1380. static void *yy_flex_realloc( void *ptr, unsigned int size )
  1381. #else
  1382. static void *yy_flex_realloc( ptr, size )
  1383. void *ptr;
  1384. unsigned int size;
  1385. #endif
  1386.     {
  1387.     return (void *) realloc( ptr, size );
  1388.     }
  1389.  
  1390. #ifdef YY_USE_PROTOS
  1391. static void yy_flex_free( void *ptr )
  1392. #else
  1393. static void yy_flex_free( ptr )
  1394. void *ptr;
  1395. #endif
  1396.     {
  1397.     free( ptr );
  1398.     }
  1399. # line 52 "./syslex.l"
  1400.